package org.wdcode.common.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

import org.wdcode.common.constants.ArrayConstants;
import org.wdcode.common.constants.EncodingConstants;
import org.wdcode.common.log.WdLogs;
import org.wdcode.common.params.WdCommonParams;
import org.wdcode.common.tools.Arrays;
import org.wdcode.common.util.CloseUtil;

/**
 * 关于IO操作
 * @author WD
 * @since JDK6
 * @version 1.0 2009-04-21
 */
public final class StreamUtil {
	/**
	 * 读取InputStream内容成为字符串 默认使用UTF-8
	 * @param in 输入流
	 * @return 读取的字符串
	 */
	public final static String readString(InputStream in) {
		return readString(in, EncodingConstants.UTF_8);
	}

	/**
	 * 读取InputStream内容成为字符串
	 * @param in 输入流
	 * @param charsetName 编码格式
	 * @return 读取的字符串
	 */
	public final static String readString(InputStream in, String charsetName) {
		// 创建可变字符序列
		StringBuilder buffer = new StringBuilder();
		// 声明BufferedReader
		BufferedReader br = null;
		try {
			// 创建BufferedReader流对象
			br = new BufferedReader(new InputStreamReader(in, charsetName), WdCommonParams.getIoBufferSize());
			// 流的缓冲
			String line;
			// 读取内容
			while ((line = br.readLine()) != null) {
				// 把流转义的字符加入到字符序列中
				buffer.append(line);
			}
		} catch (IOException e) {
			WdLogs.error(e);
		} finally {
			// 关闭资源
			CloseUtil.close(br, in);
		}
		// 返回流的字符串形式
		return buffer.toString();
	}

	/**
	 * 读取出输入流的所有字节
	 * @param in 输入流
	 * @return 字节数组
	 */
	public final static byte[] read(InputStream in) {
		// 创建结果字节数组
		byte[] result = ArrayConstants.BYTES_EMPTY;
		try {
			// 声明用于缓存的字节数组
			byte[] buffer = new byte[WdCommonParams.getIoBufferSize()];
			// 每次读取字节数组的长度
			int length = 0;
			// 循环读取流 如果读取长度大于0 继续循环
			while ((length = in.read(buffer)) > 0) {
				// 相加字节数组
				result = Arrays.add(result, buffer, length);
			}
		} catch (IOException e) {
			WdLogs.error(e);
		} finally {
			CloseUtil.close(in);
		}
		// 返回字节数组
		return result;
	}

	/**
	 * 把text写入到os中 默认使用UTF-8编码
	 * @param os 输出流
	 * @param text 输入的字符串
	 */
	public final static boolean writeString(OutputStream os, String text) {
		return writeString(os, text, EncodingConstants.UTF_8);
	}

	/**
	 * 把text写入到os中
	 * @param out 输出流
	 * @param text 输入的字符串
	 * @param charsetName 编码格式
	 * @return true false
	 */
	public final static boolean writeString(OutputStream out, String text, String charsetName) {
		// 声明BufferedWriter
		BufferedWriter bw = null;
		try {
			// 获得BufferedWriter
			bw = new BufferedWriter(new OutputStreamWriter(out, charsetName), WdCommonParams.getIoBufferSize());
			// 写入字符串
			bw.write(text);
			// 刷新文件流 把流内所有内容更新到文件上
			bw.flush();
			// 返回成功
			return true;
		} catch (IOException e) {
			WdLogs.error(e);
		} finally {
			// 关闭资源
			CloseUtil.close(bw, out);
		}
		// 返回失败
		return false;
	}

	/**
	 * 把字节数组写入到流中
	 * @param out 输出流
	 * @param b 字节数组
	 * @return 是否成功
	 */
	public final static boolean write(OutputStream out, byte[] b) {
		return write(out, new ByteArrayInputStream(b));
	}

	/**
	 * 把text写入到out中
	 * @param out 输出流
	 * @param in 输入流
	 * @return true false
	 */
	public final static boolean write(OutputStream out, InputStream in) {
		try {
			// 声明字节数组 当缓存用
			byte[] buffer = new byte[WdCommonParams.getIoBufferSize()];
			// 声明保存读取字符数量
			int num = 0;
			// 循环读取
			while ((num = in.read(buffer)) > 0) {
				// 输出到文件流
				out.write(buffer, 0, num);
			}
			// 刷新文件流 把流内所有内容更新到文件上
			out.flush();
			// 返回成功
			return true;
		} catch (IOException e) {
			WdLogs.error(e);
		} finally {
			// 关闭资源
			CloseUtil.close(out, in);
		}
		// 返回失败
		return false;
	}

	/*
	 * 私有构造
	 */
	private StreamUtil() {}
}
